home *** CD-ROM | disk | FTP | other *** search
/ Giga Games 1 / Giga Games.iso / net / hack / 2_3 / prisym.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-06-20  |  7.2 KB  |  380 lines
  1. /*    SCCS Id: @(#)prisym.c    2.3    88/03/29
  2. /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  3.  
  4. #include <stdio.h>
  5. #include "hack.h"
  6.  
  7. extern xchar scrlx, scrhx, scrly, scrhy; /* corners from pri.c */
  8.  
  9. atl(x,y,ch)
  10. register x,y;
  11. {
  12.     register struct rm *crm = &levl[x][y];
  13.  
  14.     if(x<0 || x>COLNO-1 || y<0 || y>ROWNO-1){
  15.         impossible("atl(%d,%d,%c)",x,y,ch);
  16.         return;
  17.     }
  18.     if(crm->seen && crm->scrsym == ch) return;
  19.     crm->scrsym = ch;
  20.     crm->new = 1;
  21.     on_scr(x,y);
  22. }
  23.  
  24. on_scr(x,y)
  25. register x,y;
  26. {
  27.     if(x < scrlx) scrlx = x;
  28.     if(x > scrhx) scrhx = x;
  29.     if(y < scrly) scrly = y;
  30.     if(y > scrhy) scrhy = y;
  31. }
  32.  
  33. /* call: (x,y) - display
  34.     (-1,0) - close (leave last symbol)
  35.     (-1,-1)- close (undo last symbol)
  36.     (-1,let)-open: initialize symbol
  37.     (-2,let)-change let
  38. */
  39.  
  40. tmp_at(x,y) int x,y; {
  41. static schar prevx, prevy;
  42. static char let;
  43.     if((int)x == -2){    /* change let call */
  44.         let = y;
  45.         return;
  46.     }
  47.     if((int)x == -1 && (int)y >= 0){    /* open or close call */
  48.         let = y;
  49.         prevx = -1;
  50.         return;
  51.     }
  52.     if(prevx >= 0 && cansee(prevx,prevy)) {
  53.         delay_output();
  54.         prl(prevx, prevy);    /* in case there was a monster */
  55.         at(prevx, prevy, levl[prevx][prevy].scrsym);
  56.     }
  57.     if(x >= 0){    /* normal call */
  58.         if(cansee(x,y)) at(x,y,let);
  59.         prevx = x;
  60.         prevy = y;
  61.     } else {    /* close call */
  62.         let = 0;
  63.         prevx = -1;
  64.     }
  65. }
  66.  
  67. /* like the previous, but the symbols are first erased on completion */
  68. Tmp_at(x,y) int x,y; {
  69. static char let;
  70. static xchar cnt;
  71. static coord tc[COLNO];        /* but watch reflecting beams! */
  72. register xx,yy;
  73.     if((int)x == -1) {
  74.         if(y > 0) {    /* open call */
  75.             let = y;
  76.             cnt = 0;
  77.             return;
  78.         }
  79.         /* close call (do not distinguish y==0 and y==-1) */
  80.         while(cnt--) {
  81.             xx = tc[cnt].x;
  82.             yy = tc[cnt].y;
  83.             prl(xx, yy);
  84.             at(xx, yy, levl[xx][yy].scrsym);
  85.         }
  86.         cnt = let = 0;    /* superfluous */
  87.         return;
  88.     }
  89.     if((int)x == -2) {    /* change let call */
  90.         let = y;
  91.         return;
  92.     }
  93.     /* normal call */
  94.     if(cansee(x,y)) {
  95.         if(cnt) delay_output();
  96.         at(x,y,let);
  97.         tc[cnt].x = x;
  98.         tc[cnt].y = y;
  99.         if(++cnt >= COLNO) panic("Tmp_at overflow?");
  100.         levl[x][y].new = 0;    /* prevent pline-nscr erasing --- */
  101.     }
  102. }
  103.  
  104. curs_on_u(){
  105.     curs(u.ux, u.uy+2);
  106. }
  107.  
  108. pru()
  109. {
  110.     if(u.udispl && (Invisible || u.udisx != u.ux || u.udisy != u.uy))
  111.         /* if(! levl[u.udisx][u.udisy].new) */
  112.             if(!vism_at(u.udisx, u.udisy))
  113.                 newsym(u.udisx, u.udisy);
  114.     if(Invisible) {
  115.         u.udispl = 0;
  116.         prl(u.ux,u.uy);
  117.     } else
  118.     if(!u.udispl || u.udisx != u.ux || u.udisy != u.uy) {
  119.         atl(u.ux, u.uy, u.usym);
  120.         u.udispl = 1;
  121.         u.udisx = u.ux;
  122.         u.udisy = u.uy;
  123.     }
  124.     levl[u.ux][u.uy].seen = 1;
  125. }
  126.  
  127. #ifndef NOWORM
  128. #include    "wseg.h"
  129. extern struct wseg *m_atseg;
  130. #endif
  131.  
  132. /* print a position that is visible for @ */
  133. prl(x,y)
  134. {
  135.     register struct rm *room;
  136.     register struct monst *mtmp;
  137.     register struct obj *otmp;
  138.     register struct trap *ttmp;
  139.  
  140.     if(x == u.ux && y == u.uy && (!Invisible)) {
  141.         pru();
  142.         return;
  143.     }
  144.     if(!isok(x,y)) return;
  145.     room = &levl[x][y];
  146.     if((!room->typ) ||
  147.        (IS_ROCK(room->typ) && levl[u.ux][u.uy].typ == CORR))
  148.         return;
  149.     if((mtmp = m_at(x,y)) && !mtmp->mhide &&
  150.         (!mtmp->minvis || See_invisible)) {
  151. #ifndef NOWORM
  152.         if(m_atseg)
  153.             pwseg(m_atseg);
  154.         else
  155. #endif
  156.         pmon(mtmp);
  157.     }
  158.     else if((otmp = o_at(x,y)) && room->typ != POOL)
  159.         atl(x,y,Hallucination ? rndobjsym() : otmp->olet);
  160. #ifdef SPIDERS
  161.     else if((!mtmp || mtmp->data == PM_SPIDER) &&
  162.           (ttmp = t_at(x,y)) && ttmp->ttyp == WEB)
  163.         atl(x,y,WEB_SYM);
  164. #endif
  165.     else if(mtmp && (!mtmp->minvis || See_invisible)) {
  166.         /* must be a hiding monster, but not hiding right now */
  167.         /* assume for the moment that long worms do not hide */
  168.         pmon(mtmp);
  169.     }
  170.     else if(g_at(x,y) && room->typ != POOL)
  171.         atl(x,y,Hallucination ? rndobjsym() : GOLD_SYM);
  172.     else if(!room->seen || room->scrsym == STONE_SYM) {
  173.         room->new = room->seen = 1;
  174.         newsym(x,y);
  175.         on_scr(x,y);
  176.     }
  177.     room->seen = 1;
  178. }
  179.  
  180. char
  181. news0(x,y)
  182. register xchar x,y;
  183. {
  184.     register struct obj *otmp;
  185.     register struct trap *ttmp;
  186.     struct rm *room;
  187.     register char tmp;
  188.  
  189.     room = &levl[x][y];
  190.     if(!room->seen) tmp = STONE_SYM;
  191.     else if(room->typ == POOL) tmp = POOL_SYM;
  192.     else if(!Blind && (otmp = o_at(x,y)))
  193.         tmp = Hallucination ? rndobjsym() : otmp->olet;
  194.     else if(!Blind && g_at(x,y))
  195.         tmp = Hallucination ? rndobjsym() : GOLD_SYM;
  196.     else if(x == xupstair && y == yupstair) tmp = UP_SYM;
  197.     else if(x == xdnstair && y == ydnstair) tmp = DN_SYM;
  198. #ifdef SPIDERS
  199.     else if((ttmp = t_at(x,y)) && ttmp->ttyp == WEB) tmp = WEB_SYM;
  200.     else if(ttmp && ttmp->tseen) tmp = TRAP_SYM;
  201. #else
  202.     else if((ttmp = t_at(x,y)) && ttmp->tseen) tmp = TRAP_SYM;
  203. #endif
  204.     else switch(room->typ) {
  205.     case SCORR:
  206.     case SDOOR:
  207.         tmp = room->scrsym;    /* %% wrong after killing mimic ! */
  208.         break;
  209.     case HWALL:
  210.         tmp = room->scrsym;    /* OK for corners only */
  211.         if (!IS_CORNER(tmp))
  212.             tmp = HWALL_SYM;
  213.         break;
  214.     case VWALL:
  215.         tmp = VWALL_SYM;
  216.         break;
  217.     case LDOOR:
  218.     case DOOR:
  219.         tmp = DOOR_SYM;
  220.         break;
  221.     case CORR:
  222.         tmp = CORR_SYM;
  223.         break;
  224.     case ROOM:
  225.         if(room->lit || cansee(x,y) || Blind) tmp = ROOM_SYM;
  226.         else tmp = STONE_SYM;
  227.         break;
  228. #ifdef FOUNTAINS
  229.     case FOUNTAIN:
  230.         tmp = FOUNTAIN_SYM;
  231.         break;
  232. #endif
  233. #ifdef NEWCLASS
  234.     case THRONE:
  235.         tmp = THRONE_SYM;
  236.         break;
  237. #endif
  238. #ifdef SINKS
  239.     case SINK:
  240.         tmp = SINK_SYM;
  241.         break;
  242. #endif
  243. /*
  244.     case POOL:
  245.         tmp = POOL_SYM;
  246.         break;
  247. */
  248.     default:
  249.         tmp = ERRCHAR;
  250.     }
  251.     return(tmp);
  252. }
  253.  
  254. newsym(x,y)
  255. register x,y;
  256. {
  257.     atl(x,y,news0(x,y));
  258. }
  259.  
  260. /* used with wand of digging (or pick-axe): fill scrsym and force display */
  261. /* also when a POOL evaporates */
  262. mnewsym(x,y)
  263. register x,y;
  264. {
  265.     register struct rm *room;
  266.     char newscrsym;
  267.  
  268.     if(!vism_at(x,y)) {
  269.         room = &levl[x][y];
  270.         newscrsym = news0(x,y);
  271.         if(room->scrsym != newscrsym) {
  272.             room->scrsym = newscrsym;
  273.             room->seen = 0;
  274.         }
  275.     }
  276. }
  277.  
  278. nosee(x,y)
  279. register x,y;
  280. {
  281.     register struct rm *room;
  282.  
  283.     if(!isok(x,y)) return;
  284.     room = &levl[x][y];
  285.     if(room->scrsym == ROOM_SYM && !room->lit && !Blind) {
  286.         room->scrsym = ' ';
  287.         room->new = 1;
  288.         on_scr(x,y);
  289.     }
  290. }
  291.  
  292. #ifndef QUEST
  293. prl1(x,y)
  294. register x,y;
  295. {
  296.     if(u.dx) {
  297.         if(u.dy) {
  298.             prl(x-(2*u.dx),y);
  299.             prl(x-u.dx,y);
  300.             prl(x,y);
  301.             prl(x,y-u.dy);
  302.             prl(x,y-(2*u.dy));
  303.         } else {
  304.             prl(x,y-1);
  305.             prl(x,y);
  306.             prl(x,y+1);
  307.         }
  308.     } else {
  309.         prl(x-1,y);
  310.         prl(x,y);
  311.         prl(x+1,y);
  312.     }
  313. }
  314.  
  315. nose1(x,y)
  316. register x,y;
  317. {
  318.     if(u.dx) {
  319.         if(u.dy) {
  320.             nosee(x,u.uy);
  321.             nosee(x,u.uy-u.dy);
  322.             nosee(x,y);
  323.             nosee(u.ux-u.dx,y);
  324.             nosee(u.ux,y);
  325.         } else {
  326.             nosee(x,y-1);
  327.             nosee(x,y);
  328.             nosee(x,y+1);
  329.         }
  330.     } else {
  331.         nosee(x-1,y);
  332.         nosee(x,y);
  333.         nosee(x+1,y);
  334.     }
  335. }
  336. #endif /* QUEST /**/
  337.  
  338. vism_at(x,y)
  339. register x,y;
  340. {
  341.     register struct monst *mtmp;
  342.  
  343.     if(x == u.ux && y == u.uy && !Invisible) return(1);
  344.  
  345.     if(mtmp = m_at(x,y)) return((Blind && Telepat) || canseemon(mtmp));
  346.  
  347.     return(0);
  348. }
  349.  
  350. #ifdef NEWSCR
  351. pobj(obj) register struct obj *obj; {
  352. register int show = (!obj->oinvis || See_invisible) &&
  353.         cansee(obj->ox,obj->oy);
  354.     if(obj->odispl){
  355.         if(obj->odx != obj->ox || obj->ody != obj->oy || !show)
  356.         if(!vism_at(obj->odx,obj->ody)){
  357.             newsym(obj->odx, obj->ody);
  358.             obj->odispl = 0;
  359.         }
  360.     }
  361.     if(show && !vism_at(obj->ox,obj->oy)){
  362.         atl(obj->ox,obj->oy,obj->olet);
  363.         obj->odispl = 1;
  364.         obj->odx = obj->ox;
  365.         obj->ody = obj->oy;
  366.     }
  367. }
  368. #endif /* NEWSCR /**/
  369.  
  370. unpobj(obj) register struct obj *obj; {
  371. /*     if(obj->odispl){
  372.         if(!vism_at(obj->odx, obj->ody))
  373.             newsym(obj->odx, obj->ody);
  374.         obj->odispl = 0;
  375.     }
  376. */
  377.     if(!vism_at(obj->ox,obj->oy))
  378.         newsym(obj->ox,obj->oy);
  379. }
  380.